This patch changes the behavior of how the resulting reference type of a
binding is determined. Now, the code uses the holding variables
type information of a `BindingDecl`. This seems to be consistent with
what Clang does.

The reference kind of a binding is determined by the declaration of the
structured binding.

In [dcl.struct.bind] the standard says that the reference type for a
binding is an lvalue reference if the initializer is an lvalue and
otherwise a rvalue reference. The initializer here donates to the hidden
object, referenced as e. WE declare this implicitly by declaring the
structured binding.

We get an rvalue reference in case we declare the structured binding as
a non-reference like this:
```
auto [a, b, c]
```

We get an lvalue reference if the structured binding is declared as
this:

```
auto& [a, b, c]
```

In the rvalue case we could profit from move because the contents of the
implicitly created object can be moved out.

If we have a reference to the original object moving wouldn't be a good
ting to do, hence an lvalue reference.

`std::get` has overloads for both l- and rvalues and returns the
respective reference type for each overload.

This behavior is observable thanks to #381 which shows the implicit cast
of the hidden object to a rvalue.